// Copyright (c) 2024, BlockProject 3D

//

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without modification,

// are permitted provided that the following conditions are met:

//

//     * Redistributions of source code must retain the above copyright notice,

//       this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above copyright notice,

//       this list of conditions and the following disclaimer in the documentation

//       and/or other materials provided with the distribution.

//     * Neither the name of BlockProject 3D nor the names of its contributors

//       may be used to endorse or promote products derived from this software

//       without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use crate::gen::file::Content;

use bp3d_util::path::PathExt;

use std::borrow::Cow;

use std::fmt::{Debug, Formatter};

use std::io::Write;

use std::path::{Path, PathBuf};

#[derive(Eq, PartialEq, Copy, Clone, Debug)]

pub enum FileType {

    MessageWriting,

    MessageReading,

    Message,

    Structure,

    Enum,

    Union,

}

pub struct File {

    name: Cow<'static, str>,

    data: Option<String>,

    ty: FileType,

}

impl Debug for File {

    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

        write!(f, "File {{ name: {:?}, ty: {:?} }}", self.name, self.ty)

    }

}

impl File {

    pub fn new(ty: FileType, name: impl Into<Cow<'static, str>>, data: &Content) -> Self {

        Self {

            name: name.into(),

            ty,

            data: data.to_string(),

        }

    }

    pub fn ty(&self) -> FileType {

        self.ty

    }

    pub fn write(

        self,

        out_directory: &Path,

        file_header: Option<&str>,

        extension: &str,

    ) -> std::io::Result<Option<PathBuf>> {

        if let Some(
data89
) = self.data {

  Branch (77:16): [True: 89, False: 120]

  Branch (77:16): [Folded - Ignored]

            if data.len() <= 1 {

  Branch (78:16): [True: 0, False: 89]

  Branch (78:16): [Folded - Ignored]

                return Ok(None);

            }

            let sub_folder = self.name.find("/").map(|id| 
&self.name[..id]0
);

            if let Some(
sub_folder0
) = sub_folder {

  Branch (82:20): [True: 0, False: 89]

  Branch (82:20): [Folded - Ignored]

                std::fs::create_dir(out_directory.join(sub_folder))?;

            }

            let path = out_directory.join(&*self.name).ensure_extension(extension).to_path_buf();

            let mut file = std::fs::File::create(&path)
?0
;

            if let Some(
file_header0
) = file_header {

  Branch (87:20): [True: 0, False: 89]

  Branch (87:20): [Folded - Ignored]

                file.write_all(file_header.as_bytes())?;

            }

            file.write_all(data.as_bytes())
?0
;

            file.flush()
?0
;

            drop(file);

            Ok(Some(path))

        } else {

            Ok(None)

        }

    }

}